import { useUserStore } from '@/stores/user'

/**
 * 数据权限类型枚举
 */
export const DATA_SCOPE = {
  ALL: '1',        // 全部数据权限
  CUSTOM: '2',     // 自定数据权限
  DEPT: '3',       // 部门数据权限
  DEPT_AND_CHILD: '4', // 部门及以下数据权限
  SELF: '5'        // 仅本人数据权限
}

/**
 * 获取用户数据权限范围
 * @returns {string} 数据权限范围
 */
export function getDataScope() {
  const userStore = useUserStore()
  const roles = userStore.roles
  
  // 超级管理员拥有全部数据权限
  if (roles.includes('admin')) {
    return DATA_SCOPE.ALL
  }
  
  // 部门管理员拥有部门及以下数据权限
  if (roles.includes('dept_admin')) {
    return DATA_SCOPE.DEPT_AND_CHILD
  }
  
  // 普通用户只能查看自己的数据
  return DATA_SCOPE.SELF
}

/**
 * 根据数据权限过滤数据
 * @param {Array} data - 原始数据
 * @param {Object} options - 过滤选项
 * @param {string} options.userIdField - 用户ID字段名，默认为 'userId'
 * @param {string} options.deptIdField - 部门ID字段名，默认为 'deptId'
 * @param {string} options.createByField - 创建者字段名，默认为 'createBy'
 * @returns {Array} 过滤后的数据
 */
export function filterDataByPermission(data, options = {}) {
  const {
    userIdField = 'userId',
    deptIdField = 'deptId',
    createByField = 'createBy'
  } = options
  
  const userStore = useUserStore()
  const currentUserId = userStore.userInfo.id
  const currentDeptId = userStore.userInfo.deptId
  const dataScope = getDataScope()
  
  if (!Array.isArray(data)) {
    return data
  }
  
  switch (dataScope) {
    case DATA_SCOPE.ALL:
      // 全部数据权限，返回所有数据
      return data
      
    case DATA_SCOPE.CUSTOM:
      // 自定义数据权限，需要根据具体业务逻辑实现
      return filterCustomData(data, options)
      
    case DATA_SCOPE.DEPT:
      // 部门数据权限，只能查看本部门数据
      return data.filter(item => 
        item[deptIdField] === currentDeptId
      )
      
    case DATA_SCOPE.DEPT_AND_CHILD:
      // 部门及以下数据权限，可以查看本部门及子部门数据
      return filterDeptAndChildData(data, currentDeptId, deptIdField)
      
    case DATA_SCOPE.SELF:
      // 仅本人数据权限，只能查看自己创建的数据
      return data.filter(item => 
        item[userIdField] === currentUserId || 
        item[createByField] === currentUserId
      )
      
    default:
      return []
  }
}

/**
 * 过滤自定义数据权限
 * @param {Array} data - 原始数据
 * @param {Object} options - 过滤选项
 * @returns {Array} 过滤后的数据
 */
function filterCustomData(data, options) {
  const userStore = useUserStore()
  const customDataScope = userStore.userInfo.customDataScope || []
  
  // 根据自定义数据权限范围过滤
  return data.filter(item => {
    return customDataScope.some(scope => {
      // 这里可以根据具体业务逻辑实现
      return item.deptId === scope.deptId || item.userId === scope.userId
    })
  })
}

/**
 * 过滤部门及子部门数据
 * @param {Array} data - 原始数据
 * @param {string} deptId - 部门ID
 * @param {string} deptIdField - 部门ID字段名
 * @returns {Array} 过滤后的数据
 */
function filterDeptAndChildData(data, deptId, deptIdField) {
  // 这里需要获取部门树结构，找出所有子部门
  const childDeptIds = getChildDeptIds(deptId)
  
  return data.filter(item => 
    childDeptIds.includes(item[deptIdField])
  )
}

/**
 * 获取子部门ID列表
 * @param {string} deptId - 父部门ID
 * @returns {Array} 子部门ID列表
 */
function getChildDeptIds(deptId) {
  // 模拟部门树结构
  const deptTree = [
    { id: '1', parentId: null, name: '总公司' },
    { id: '2', parentId: '1', name: '技术部' },
    { id: '3', parentId: '1', name: '销售部' },
    { id: '4', parentId: '2', name: '前端组' },
    { id: '5', parentId: '2', name: '后端组' }
  ]
  
  const result = [deptId]
  
  function findChildren(parentId) {
    deptTree.forEach(dept => {
      if (dept.parentId === parentId) {
        result.push(dept.id)
        findChildren(dept.id)
      }
    })
  }
  
  findChildren(deptId)
  return result
}

/**
 * 检查是否有数据操作权限
 * @param {Object} data - 数据对象
 * @param {string} operation - 操作类型：'view', 'edit', 'delete'
 * @param {Object} options - 选项
 * @returns {boolean} 是否有权限
 */
export function hasDataPermission(data, operation = 'view', options = {}) {
  const userStore = useUserStore()
  const currentUserId = userStore.userInfo.id
  const roles = userStore.roles
  
  // 超级管理员拥有所有权限
  if (roles.includes('admin')) {
    return true
  }
  
  const {
    userIdField = 'userId',
    createByField = 'createBy'
  } = options
  
  // 检查是否是数据创建者
  const isCreator = data[userIdField] === currentUserId || 
                   data[createByField] === currentUserId
  
  switch (operation) {
    case 'view':
      // 查看权限：根据数据权限范围判断
      return filterDataByPermission([data], options).length > 0
      
    case 'edit':
      // 编辑权限：创建者或有编辑权限的角色
      return isCreator || roles.includes('editor')
      
    case 'delete':
      // 删除权限：创建者或管理员
      return isCreator || roles.includes('admin')
      
    default:
      return false
  }
}

/**
 * 数据权限装饰器
 * @param {Function} apiFunction - API函数
 * @param {Object} options - 选项
 * @returns {Function} 装饰后的函数
 */
export function withDataPermission(apiFunction, options = {}) {
  return async function(...args) {
    const result = await apiFunction.apply(this, args)
    
    if (result && result.data) {
      // 如果返回的是数组，进行数据权限过滤
      if (Array.isArray(result.data)) {
        result.data = filterDataByPermission(result.data, options)
      }
      // 如果返回的是分页数据
      else if (result.data.records && Array.isArray(result.data.records)) {
        result.data.records = filterDataByPermission(result.data.records, options)
        result.data.total = result.data.records.length
      }
    }
    
    return result
  }
}
